home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / AHDI / TSTDRIVE / TSTDRIVE.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  7.9 KB  |  392 lines
  1. /* 
  2.  * TSTDRIVE.C    ml.    Oct 10 1989
  3.  *
  4.  * Front end to test all driver routines (ACSI or SCSI).
  5.  */
  6.  
  7. #include    <osbind.h>
  8. #include    "define.h"
  9.  
  10. WORD    hex;
  11. WORD    useblit;
  12. BYTE    spscsixst;
  13.  
  14. extern     WORD    untrdy(), rqsense(), format(), hread(), hwrite(),
  15.         inquiry(), mdselect(), mdsense(), stunit(),
  16.         readcap(), xtdread(), xtdwrt();
  17.         
  18. extern    WORD    recal(), ideread(), idewrite(), verify(), fmtunt(), 
  19.         seek(), diag(), initparm(), rsbuf(), wsbuf(), 
  20.         identify(), standby(), active(), sbwto(), awto(), 
  21.         ssc(), sbres();
  22. main()
  23. {
  24.     BYTE    command[80], *askbuf(), *buf;
  25.     UWORD    head, cyl, spt;
  26.     UWORD    pdev, count, len, pcode, pcf, inlv, pmi;
  27.     WORD    ret;
  28.     LONG    oldssp;
  29.     LONG    sect, size, asksect(), asksize();
  30.  
  31.     useblit = 0;
  32.     spscsixst = (BYTE)chkspscsi();
  33.     hex = TRUE;        /* default to hex mode */
  34.     oldssp = Super(0L);
  35.     while (1) {
  36.         command[0] = 78;
  37.         usrprompt("\nCommand: ", &command[0]);
  38.         
  39.         if (!strcmp(&command[2], "tstunit")) {
  40.             pdev = askpdev();
  41.             ret = untrdy(pdev);
  42.             reply((LONG)ret);
  43.         } else if (!strcmp(&command[2], "rqsense")) {
  44.             pdev = askpdev();
  45.             len = asklen();
  46.             buf = askbuf();
  47.             ret = rqsense(pdev, len, buf);
  48.             reply((LONG)ret);
  49.         } else if (!strcmp(&command[2], "format")) {
  50.             pdev = askpdev();
  51.             inlv = askinlv();
  52.             ret = format(pdev, inlv);
  53.             reply((LONG)ret);
  54.         } else if (!strcmp(&command[2], "hread")) {
  55.             sect = asksect();
  56.             count = askcnt();
  57.             buf = askbuf();
  58.             pdev = askpdev();
  59.             ret = hread(sect, count, buf, pdev);
  60.             reply((LONG)ret);
  61.         } else if (!strcmp(&command[2], "hwrite")) {
  62.             sect = asksect();
  63.             count = askcnt();
  64.             buf = askbuf();
  65.             pdev = askpdev();
  66.             ret = hwrite(sect, count, buf, pdev);
  67.             reply((LONG)ret);
  68.         } else if (!strcmp(&command[2], "inquiry")) {
  69.             pdev = askpdev();
  70.             len = asklen();
  71.             buf = askbuf();
  72.             ret = inquiry(pdev, len, buf);
  73.             reply((LONG)ret);
  74.         } else if (!strcmp(&command[2], "mdselect")) {
  75.             pdev = askpdev();
  76.             len = asklen();
  77.             buf = askbuf();
  78.             ret = mdselect(pdev, len, buf);
  79.             reply((LONG)ret);
  80.         } else if (!strcmp(&command[2], "mdsense")) {
  81.             pdev = askpdev();
  82.             pcode = askpcode();
  83.             pcf = askpcf();
  84.             len = asklen();
  85.             buf = askbuf();
  86.             ret = mdsense(pdev, pcode, pcf, len, buf);
  87.             reply((LONG)ret);
  88.         } else if (!strcmp(&command[2], "start")) {
  89.             pdev = askpdev();
  90.             ret = stunit(pdev, 1);
  91.             reply((LONG)ret);
  92.         } else if (!strcmp(&command[2], "stop")) {
  93.             pdev = askpdev();
  94.             ret = stunit(pdev, 0);
  95.             reply((LONG)ret);
  96.         } else if (!strcmp(&command[2], "readcap")) {
  97.             pdev = askpdev();
  98.             pmi = askpmi();
  99.             sect = asksect();
  100.             buf = askbuf();
  101.             ret = readcap(pdev, pmi, sect, buf);
  102.             reply((LONG)ret);
  103.         } else if (!strcmp(&command[2], "xread")) {
  104.             sect = asksect();
  105.             count = askcnt();
  106.             buf = askbuf();
  107.             pdev = askpdev();
  108.             ret = xtdread(sect, count, buf, pdev);
  109.             reply((LONG)ret);
  110.         } else if (!strcmp(&command[2], "xwrite")) {
  111.             sect = asksect();
  112.             count = askcnt();
  113.             buf = askbuf();
  114.             pdev = askpdev();
  115.             ret = xtdwrt(sect, count, buf, pdev);
  116.             reply((LONG)ret);
  117.         } else if (!strcmp(&command[2], "malloc")) {
  118.             size = asksize();
  119.             reply((LONG)Malloc(size));
  120. /*
  121.         } else if (!strcmp(&command[2], "dump")) {
  122.             buf = askbuf();
  123.             dump(buf);
  124. /**/
  125.         } else if (!strcmp(&command[2], "identify")) {
  126.             pdev = askpdev();
  127.             buf = askbuf();
  128.             ret = identify(pdev, buf);
  129.             reply((LONG)ret);
  130.         } else if (!strcmp(&command[2], "recal")) {
  131.             pdev = askpdev();
  132.             ret = recal(pdev);
  133.             reply((LONG)ret);
  134.         } else if (!strcmp(&command[2], "initparm")) {
  135.             pdev = askpdev();
  136.             head = askhead();
  137.             spt = askspt();
  138.             ret = initparm(pdev, head, spt);
  139.             reply((LONG)ret);
  140.         } else if (!strcmp(&command[2], "seek")) {
  141.             pdev = askpdev();
  142.             cyl = askcyl();
  143.             head = askhead();
  144.             ret = seek(pdev, head, cyl);
  145.             reply((LONG)ret);
  146.         } else if (!strcmp(&command[2], "iread")) {
  147.             head = askhead();
  148.             spt = askspt();
  149.             sect = asksect();
  150.             count = askcnt();
  151.             buf = askbuf();
  152.             pdev = askpdev();
  153.             ret = ideread(head, spt, sect, count, buf, pdev);
  154.             reply((LONG)ret);
  155.         } else if (!strcmp(&command[2], "iwrite")) {
  156.             head = askhead();
  157.             spt = askspt();
  158.             sect = asksect();
  159.             count = askcnt();
  160.             buf = askbuf();
  161.             pdev = askpdev();
  162.             ret = idewrite(head, spt, sect, count, buf, pdev);
  163.             reply((LONG)ret);
  164.         } else if (!strcmp(&command[2], "verify")) {
  165.             sect = asksect();
  166.             count = askcnt();
  167.             pdev = askpdev();
  168.             ret = verify(sect, count, pdev);
  169.             reply((LONG)ret);
  170.         } else if (!strcmp(&command[2], "fmtunt")) {
  171.             pdev = askpdev();
  172.             ret = fmtunt(pdev);
  173.             reply((LONG)ret);
  174.         } else if (!strcmp(&command[2], "diag")) {
  175.             ret = diag();
  176.             reply((LONG)ret);
  177.         } else if (!strcmp(&command[2], "rsbuf")) {
  178.             pdev = askpdev();
  179.             buf = askbuf();
  180.             ret = rsbuf(pdev, buf);
  181.             reply((LONG)ret);
  182.         } else if (!strcmp(&command[2], "wsbuf")) {
  183.             pdev = askpdev();
  184.             buf = askbuf();
  185.             ret = wsbuf(pdev, buf);
  186.             reply((LONG)ret);
  187.         } else if (!strcmp(&command[2], "standby")) {
  188.             pdev = askpdev();
  189.             ret = standby(pdev);
  190.             reply((LONG)ret);
  191.         } else if (!strcmp(&command[2], "active")) {
  192.             pdev = askpdev();
  193.             ret = active(pdev);
  194.             reply((LONG)ret);
  195.         } else if (!strcmp(&command[2], "sbwto")) {
  196.             pdev = askpdev();
  197.             count = askcnt();
  198.             ret = sbwto(pdev, count);
  199.             reply((LONG)ret);
  200.         } else if (!strcmp(&command[2], "awto")) {
  201.             pdev = askpdev();
  202.             count = askcnt();
  203.             ret = awto(pdev, count);
  204.             reply((LONG)ret);
  205.         } else if (!strcmp(&command[2], "ssc")) {
  206.             pdev = askpdev();
  207.             ret = ssc(pdev);
  208.             reply((LONG)ret);
  209.         } else if (!strcmp(&command[2], "sbres")) {
  210.             pdev = askpdev();
  211.             ret = sbres(pdev);
  212.             reply((LONG)ret);
  213.         } else if (!strcmp(&command[2], "help")) {
  214.             
  215.         } else if (!strcmp(&command[2], "hex")) {
  216.             hex = TRUE;
  217.             reply(0L);
  218.         } else if (!strcmp(&command[2], "dec")) {
  219.             hex = FALSE;
  220.             reply(0L);
  221.         } else {
  222.             Cconws("\n\rInvalid command...");
  223.         }
  224.     }
  225.     Super(oldssp);
  226.     Pterm0();
  227. }    
  228.  
  229.  
  230. askpdev()
  231. {
  232.     return (ask4int("Physical unit #: "));
  233. }
  234.  
  235.  
  236. askcyl()
  237. {
  238.     return (ask4int("Cylinder #: "));
  239. }
  240.  
  241.  
  242. askhead()
  243. {
  244.     return (ask4int("Head #: "));
  245. }
  246.  
  247.  
  248. askspt()
  249. {
  250.     return (ask4int("Sectors Per Track: "));
  251. }
  252.  
  253.  
  254. asklen()
  255. {
  256.     return (ask4int("Length requesting (in bytes): "));
  257. }
  258.  
  259.  
  260. askinlv()
  261. {
  262.     return (ask4int("Interleave factor: "));
  263. }
  264.  
  265.  
  266. LONG
  267. asksect()
  268. {
  269.     LONG    ask4long();
  270.     
  271.     return (ask4long("Starting sector #: "));
  272. }
  273.  
  274.  
  275. LONG
  276. asksize()
  277. {
  278.     LONG    ask4long();
  279.     
  280.     return (ask4long("Size of buffer to be allocated: "));
  281. }
  282.  
  283.  
  284. askcnt()
  285. {
  286.     return (ask4int("Count: "));
  287. }
  288.  
  289.  
  290. askpcode()
  291. {
  292.     return (ask4int("Pcode: "));
  293. }
  294.  
  295.  
  296. askpcf()
  297. {
  298.     return (ask4int("Pcf: "));
  299. }
  300.  
  301.  
  302. askpmi()
  303. {
  304.     return (ask4int("Pmi: "));
  305. }
  306.  
  307.  
  308. BYTE *
  309. askbuf()
  310. {
  311.     BYTE    response[80];
  312.     LONG    size, asksize(), buf;
  313.     
  314. askagn:    response[0] = 78;
  315.     usrprompt("Buffer address: ", &response[0]);
  316.     if (!strcmp(&response[2], "malloc")) {
  317.         size = asksize();
  318.         reply(Malloc(size));
  319.         goto askagn;
  320.     }
  321.     
  322.     if (hex)
  323.         htol(&response[2], &buf);
  324.     else
  325.         atol(&response[2], &buf);
  326.         
  327.     return ((BYTE *)buf);
  328. }
  329.  
  330.  
  331. ask4int(prompt)
  332. BYTE    *prompt;
  333. {
  334.     BYTE    response[80];
  335.     
  336.     response[0] = 78;
  337.     usrprompt(prompt, &response[0]);
  338.     if (hex)
  339.         return (htoi(&response[2]));
  340.     else
  341.         return (atoi(&response[2]));
  342. }
  343.  
  344.  
  345. LONG
  346. ask4long(prompt)
  347. BYTE    *prompt;
  348. {
  349.     BYTE    response[80];
  350.     LONG    ret;
  351.     
  352.     response[0] = 78;
  353.     usrprompt(prompt, &response[0]);
  354.     if (hex)
  355.         htol(&response[2], &ret);
  356.     else
  357.         atol(&response[2], &ret);
  358.         
  359.     return (ret);
  360. }
  361.  
  362.  
  363. usrprompt(prompt, response)
  364. BYTE    *prompt;
  365. BYTE    *response;
  366. {
  367.     Cconws("\n\r");
  368.     Cconws(prompt);
  369.     while (!Cconis())        /* waiting for character */
  370.         ;
  371.     Cconrs(response);
  372.     *(response+(*(response+1)+2)) = 0;    /* NULL terminated */
  373. }
  374.  
  375.  
  376. reply(ret)
  377. LONG    ret;
  378. {
  379.     BYTE    result[10];
  380.     
  381.     if (hex)
  382.         ltoh(ret, result);
  383.     else
  384.         ltoa(ret, result);
  385.         
  386.     Cconws("\n\rReturns: ");
  387.     Cconws(result);
  388. }
  389.  
  390.  
  391.  
  392.